home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / diff1819.zoo / diff1819.txt < prev   
Encoding:
Text File  |  1993-08-16  |  14.4 KB  |  603 lines
  1. *** 1.8    1993/08/10 20:46:44
  2. --- changes    1993/08/16 23:11:16
  3. ***************
  4. *** 1,6 ****
  5. --- 1,20 ----
  6.   Changes are listed in *reverse* order, most recent changes being
  7.   first.
  8.   
  9. + version 1.09
  10. + 
  11. + biosfs.c:
  12. +     Implement file locking for BIOS devices.
  13. + dosmem.c:
  14. +     Fix the Pexec(200,...) bug (trying to save the command line
  15. +     image must be done *before* the existing program's memory
  16. +     is freed).
  17. + nalloc2.c,util.c:
  18. +     Allow kmalloc()'d memory to be returned to the OS, if possible.
  19. + xbios.c:
  20. +     Dosound() can be called with a negative number as its parameter,
  21. +     in which case it is only an inquiry function.
  22. + 
  23.   version 1.08
  24.   
  25.   dosfile.c,dosdir.c,filesys.c:
  26. *** 1.8    1993/08/10 20:46:44
  27. --- biosfs.c    1993/08/16 23:10:54
  28. ***************
  29. *** 41,46 ****
  30. --- 41,47 ----
  31.   static long    ARGS_ON_STACK bios_select    P_((FILEPTR *f, long p, int mode));
  32.   static void    ARGS_ON_STACK bios_unselect    P_((FILEPTR *f, long p, int mode));
  33.   static long    ARGS_ON_STACK bios_tseek    P_((FILEPTR *f, long where, int whence));
  34. + static long    ARGS_ON_STACK bios_close    P_((FILEPTR *f, int pid));
  35.   
  36.   long    ARGS_ON_STACK null_open    P_((FILEPTR *f));
  37.   long    ARGS_ON_STACK null_write    P_((FILEPTR *f, const char *buf, long bytes));
  38. ***************
  39. *** 63,69 ****
  40.   
  41.   DEVDRV bios_tdevice = {
  42.       bios_topen, bios_twrite, bios_tread, bios_tseek, bios_ioctl,
  43. !     null_datime, null_close, bios_select, bios_unselect
  44.   };
  45.   
  46.   /* device driver for BIOS devices that are not terminals */
  47. --- 64,70 ----
  48.   
  49.   DEVDRV bios_tdevice = {
  50.       bios_topen, bios_twrite, bios_tread, bios_tseek, bios_ioctl,
  51. !     null_datime, bios_close, bios_select, bios_unselect
  52.   };
  53.   
  54.   /* device driver for BIOS devices that are not terminals */
  55. ***************
  56. *** 70,76 ****
  57.   
  58.   DEVDRV bios_ndevice = {
  59.       null_open, bios_nwrite, bios_nread, null_lseek, bios_ioctl,
  60. !     null_datime, null_close, bios_select, bios_unselect
  61.   };
  62.   
  63.   DEVDRV null_device = {
  64. --- 71,77 ----
  65.   
  66.   DEVDRV bios_ndevice = {
  67.       null_open, bios_nwrite, bios_nread, null_lseek, bios_ioctl,
  68. !     null_datime, bios_close, bios_select, bios_unselect
  69.   };
  70.   
  71.   DEVDRV null_device = {
  72. ***************
  73. *** 117,122 ****
  74. --- 118,124 ----
  75.       ushort    flags;            /* flags for device open */
  76.       struct tty *tty;        /* tty structure (if appropriate) */
  77.       struct bios_file *next;
  78. +     short    lockpid;        /* owner of the lock */
  79.   };
  80.   
  81.   struct bios_file BDEV[] = {
  82. ***************
  83. *** 1024,1029 ****
  84. --- 1026,1032 ----
  85.       char *aline;
  86.       short dev;
  87.       int i;
  88. +     struct bios_file *b;
  89.   
  90.       if (mode == FIONREAD) {
  91.           if (bconstat(f->fc.aux))
  92. ***************
  93. *** 1175,1180 ****
  94. --- 1178,1218 ----
  95.               r = 0;
  96.           }
  97.           return r;
  98. +     } else if (mode == F_SETLK || mode == F_SETLKW) {
  99. +         struct flock *lck = (struct flock *)buf;
  100. + 
  101. +         b = (struct bios_file *)f->fc.index;
  102. +         while (b->lockpid && b->lockpid != curproc->pid) {
  103. +             if (mode == F_SETLKW && lck->l_type != F_UNLCK)
  104. +                 sleep(IO_Q, (long)b);
  105. +             else
  106. +                 return ELOCKED;
  107. +         }
  108. +         if (lck->l_type == F_UNLCK) {
  109. +             if (!(f->flags & O_LOCK)) {
  110. +                 DEBUG(("bios_ioctl: wrong file descriptor for UNLCK"));
  111. +                 return ENSLOCK;
  112. +             }
  113. +             if (b->lockpid != curproc->pid)
  114. +                 return ENSLOCK;
  115. +             b->lockpid = 0;
  116. +             f->flags &= ~O_LOCK;
  117. +             wake(IO_Q, (long)b);    /* wake anyone waiting for this lock */
  118. +         } else {
  119. +             b->lockpid = curproc->pid;
  120. +             f->flags |= O_LOCK;
  121. +         }
  122. +     } else if (mode == F_GETLK) {
  123. +         struct flock *lck = (struct flock *)buf;
  124. + 
  125. +         b = (struct bios_file *)f->fc.index;
  126. +         if (b->lockpid) {
  127. +             lck->l_type = F_WRLCK;
  128. +             lck->l_start = lck->l_len = 0;
  129. +             lck->l_pid = b->lockpid;
  130. +         } else {
  131. +             lck->l_type = F_UNLCK;
  132. +         }
  133.       } else {
  134.       /* Fcntl will automatically call tty_ioctl to handle
  135.        * terminal calls that we didn't deal with
  136. ***************
  137. *** 1231,1236 ****
  138. --- 1269,1288 ----
  139.           else if (mode == O_WRONLY && tty->wsel == p)
  140.               tty->wsel = 0;
  141.       }
  142. + }
  143. + 
  144. + static long ARGS_ON_STACK 
  145. + bios_close(f, pid)
  146. +     FILEPTR *f;
  147. +     int pid;
  148. + {
  149. +     struct bios_file *b;
  150. + 
  151. +     b = (struct bios_file *)f->fc.index;
  152. +     if ((f->flags & O_LOCK) && (b->lockpid == pid)) {
  153. +         b->lockpid = 0;
  154. +     }
  155. +     return 0;
  156.   }
  157.   
  158.   /*
  159. *** 1.8    1993/08/10 20:46:44
  160. --- debug.c    1993/08/13 18:41:26
  161. ***************
  162. *** 608,616 ****
  163.           out_device = 2;
  164.           break;
  165.       case 0x3f:        /* F5: dump memory */
  166. !         DUMPMEM(ker);
  167. !         DUMPMEM(core);
  168. !         DUMPMEM(alt);
  169.           break;
  170.       case 0x40:        /* F6: dump processes */
  171.           DUMPPROC();
  172. --- 608,617 ----
  173.           out_device = 2;
  174.           break;
  175.       case 0x3f:        /* F5: dump memory */
  176. !         DUMP_ALL_MEM();
  177. !         break;
  178. !     case 0x58:        /* shift+F5: dump kernel allocated memory */
  179. !         NALLOC_DUMP();
  180.           break;
  181.       case 0x40:        /* F6: dump processes */
  182.           DUMPPROC();
  183. *** 1.8    1993/08/10 20:46:44
  184. --- dosmem.c    1993/08/16 18:28:26
  185. ***************
  186. *** 543,548 ****
  187. --- 543,571 ----
  188.               }
  189.               return mint_errno;
  190.           }
  191. + 
  192. +     /* jr: add Pexec information to PROC struct */
  193. +         strncpy(p->cmdlin, b->p_cmdlin, 128);
  194. +         p->fname[0] = 0;
  195. +         if (mkload) {
  196. +             char tmp[PATH_MAX];
  197. +             char *source = ptr1;
  198. +             tmp[1] = ':';
  199. +             if (source[1] == ':') {
  200. +                 tmp[0] = source[0];
  201. +                 source += 2;
  202. +             } else
  203. +                 tmp[0] = 'A' + curproc->curdrv;
  204. +             if (DIRSEP(source[0]))    /* absolute path? */
  205. +             {
  206. +                 strncpy (&tmp[2], &source[0], PATH_MAX-2);
  207. +                 strcpy (p->fname, tmp);
  208. +             } else {
  209. +                 if (! d_getcwd (&tmp[2], tmp[0] - 'A' + 1, PATH_MAX - 2))
  210. +                     ksprintf (p->fname, "%s\\%s", tmp, source);
  211. +             }
  212. +         }
  213. + 
  214.           if (ptrace)
  215.               p->ptracer = pid2proc(p->ppid);
  216.   
  217. ***************
  218. *** 588,618 ****
  219.           if (p->ptracer)
  220.               p->ctxt[CURRENT].ptrace = 1;
  221.   
  222. -     /* jr: add Pexec information to PROC struct */
  223. -     p->cmdlin[0] = 0;
  224. -     if (mkbase || mkload)
  225. -         strncpy(p->cmdlin, ptr2, 128);
  226. -     p->fname[0] = 0;
  227. -     if (mkload)
  228. -     {
  229. -         char tmp[PATH_MAX];
  230. -         char *source = ptr1;
  231. -         tmp[1] = ':';
  232. -         if (source[1] == ':') {
  233. -             tmp[0] = source[0];
  234. -             source += 2;
  235. -         } else
  236. -             tmp[0] = 'A' + curproc->curdrv;
  237. -         if (DIRSEP(source[0]))    /* absolute path? */
  238. -         {
  239. -             strncpy (&tmp[2], &source[0], PATH_MAX-2);
  240. -             strcpy (p->fname, tmp);
  241. -         } else {
  242. -             if (! d_getcwd (&tmp[2], tmp[0] - 'A' + 1, PATH_MAX - 2))
  243. -                 ksprintf (p->fname, "%s\\%s", tmp, source);
  244. -         }
  245. -     }
  246. - 
  247.       /* set the time/date stamp of u:\proc */
  248.           proctime = timestamp;
  249.           procdate = datestamp;
  250. --- 611,616 ----
  251. ***************
  252. *** 1137,1143 ****
  253. --- 1135,1144 ----
  254.       assert(p != curproc);
  255.   
  256.   /* take the child off both the global and ZOMBIE lists */
  257. +     { short sr = spl7();
  258.       rm_q(ZOMBIE_Q, p);
  259. +     spl(sr);
  260. +     }
  261.   
  262.       if (proclist == p) {
  263.           proclist = p->gl_next;
  264. *** 1.8    1993/08/10 20:46:44
  265. --- mem.c    1993/08/13 18:11:30
  266. ***************
  267. *** 33,46 ****
  268.    */
  269.   
  270.   /* initial number of memory regions */
  271. ! #define NREGIONS 512
  272.   
  273.   /* number of new regions to allocate when the initial ones are used up */
  274. ! #define NEWREGIONS 256
  275.   
  276.   static MEMREGION use_regions[NREGIONS+1];
  277.   MEMREGION *rfreelist;
  278.   
  279.   /* these variables are set in init_core(), and used in
  280.    * init_mem()
  281.    */
  282. --- 33,51 ----
  283.    */
  284.   
  285.   /* initial number of memory regions */
  286. ! #define NREGIONS ((8*1024)/sizeof(MEMREGION))
  287.   
  288.   /* number of new regions to allocate when the initial ones are used up */
  289. ! #define NEWREGIONS ((8*1024)/sizeof(MEMREGION))
  290.   
  291.   static MEMREGION use_regions[NREGIONS+1];
  292.   MEMREGION *rfreelist;
  293.   
  294. + /* variable for debugging purposes; number of times we've needed
  295. +  * to get new regions
  296. +  */
  297. + int num_reg_requests = 0;
  298. + 
  299.   /* these variables are set in init_core(), and used in
  300.    * init_mem()
  301.    */
  302. ***************
  303. *** 342,347 ****
  304. --- 347,353 ----
  305.               newstuff = get_region(core, NEWREGIONS*SIZEOF(MEMREGION), PROT_S);
  306.           newfrees = newstuff ? (MEMREGION *)newstuff->loc : 0;
  307.           if (newfrees) {
  308. +             num_reg_requests++;
  309.               newfrees[NEWREGIONS-1].next = 0;
  310.               newfrees[NEWREGIONS-1].links = 0;
  311.               for (i = 0; i < NEWREGIONS-1; i++) {
  312. ***************
  313. *** 1609,1617 ****
  314. --- 1615,1626 ----
  315.   void
  316.   DUMP_ALL_MEM()
  317.   {
  318. + #ifdef DEBUG_INFO
  319.       DUMPMEM(ker);
  320.       DUMPMEM(core);
  321.       DUMPMEM(alt);
  322. +     FORCE("new memory region descriptor pages: %d", num_reg_requests);
  323. + #endif
  324.   }
  325.   
  326.   void
  327. *** 1.8    1993/08/10 20:46:44
  328. --- nalloc2.c    1993/08/13 20:36:48
  329. ***************
  330. *** 1,5 ****
  331.   /*
  332. !  * Copyright 1992 Atari Corporation. All rights reserved.
  333.    */
  334.   
  335.   /*
  336. --- 1,6 ----
  337.   /*
  338. !  * Copyright 1992,1993 Atari Corporation.
  339. !  * All rights reserved.
  340.    */
  341.   
  342.   /*
  343. ***************
  344. *** 65,75 ****
  345.   void *start;
  346.   long len;
  347.   {
  348. !     struct arena *a = start;
  349.       struct block *b;
  350.   
  351. !     a->a_next = a_first;
  352. !     a_first = a;
  353.       a->a_ffirst = b = (struct block *)(a+1);
  354.       a->a_size = len;
  355.       b->b_next = NULL;
  356. --- 66,82 ----
  357.   void *start;
  358.   long len;
  359.   {
  360. !     struct arena *a;
  361.       struct block *b;
  362.   
  363. !     for (a = a_first; a && a->a_next; a = a->a_next)
  364. !     continue;
  365. !     if (a)
  366. !         a->a_next = (struct arena *)start;
  367. !     else
  368. !         a_first = (struct arena *)start;
  369. !     a = start;
  370. !     a->a_next = NULL;
  371.       a->a_ffirst = b = (struct block *)(a+1);
  372.       a->a_size = len;
  373.       b->b_next = NULL;
  374. ***************
  375. *** 230,244 ****
  376.       fb->b_next = b->b_next;
  377.       }
  378.   
  379. - #if 0
  380.       /* if, after coalescing, this arena is entirely free, Mfree it! */
  381. !     if (a->a_ffirst == a+1 && 
  382.           (a->a_ffirst->b_size + sizeof(struct block)) == a->a_size) {
  383.           NALLOC_DEBUG('!');
  384.           *qa = a->a_next;
  385.           (void)Mfree(a);
  386. -     }
  387.   #endif
  388.   
  389.       return;
  390.   }
  391. --- 237,253 ----
  392.       fb->b_next = b->b_next;
  393.       }
  394.   
  395.       /* if, after coalescing, this arena is entirely free, Mfree it! */
  396. !     if ((struct arena *)a->a_ffirst == a+1 && 
  397.           (a->a_ffirst->b_size + sizeof(struct block)) == a->a_size) {
  398.           NALLOC_DEBUG('!');
  399.           *qa = a->a_next;
  400. + #if 1
  401. +         kfree(a);    /* MiNT -- give back so it can be used by users */
  402. + #else
  403.           (void)Mfree(a);
  404.   #endif
  405. +     }
  406.   
  407.       return;
  408.   }
  409. *** 1.8    1993/08/10 20:46:44
  410. --- proc.c    1993/08/13 22:46:50
  411. ***************
  412. *** 1,6 ****
  413.   /*
  414.   Copyright 1990,1991,1992 Eric R. Smith.
  415. ! Copyright 1992 Atari Corporation.
  416.   All rights reserved.
  417.   */
  418.   
  419. --- 1,6 ----
  420.   /*
  421.   Copyright 1990,1991,1992 Eric R. Smith.
  422. ! Copyright 1992,1993 Atari Corporation.
  423.   All rights reserved.
  424.   */
  425.   
  426. *** 1.8    1993/08/10 20:46:44
  427. --- procfs.c    1993/08/13 22:49:58
  428. ***************
  429. *** 553,558 ****
  430. --- 553,559 ----
  431.   {
  432.       PROC *p;
  433.       extern long mcpu;    /* in main.c */
  434. +     short sr;
  435.   
  436.       p = (PROC *)f->devinfo;
  437.       switch(mode) {
  438. ***************
  439. *** 654,661 ****
  440. --- 655,664 ----
  441.   TRACE(("PTRACEGO: no signal"));
  442.           }
  443.   /* wake the process up */
  444. +         sr = spl7();
  445.           rm_q(p->wait_q, p);
  446.           add_q(READY_Q, p);
  447. +         spl(sr);
  448.           return 0;
  449.       /* jr: PLOADINFO returns information about params passed to Pexec */
  450.       case PLOADINFO:
  451. *** 1.8    1993/08/10 20:46:44
  452. --- util.c    1993/08/13 19:00:52
  453. ***************
  454. *** 1,6 ****
  455.   /*
  456.   Copyright 1990,1991,1992 Eric R. Smith.
  457. ! Copyright 1992 Atari Corporation.
  458.   All rights reserved.
  459.   */
  460.   
  461. --- 1,6 ----
  462.   /*
  463.   Copyright 1990,1991,1992 Eric R. Smith.
  464. ! Copyright 1992,1993 Atari Corporation.
  465.   All rights reserved.
  466.   */
  467.   
  468. ***************
  469. *** 107,113 ****
  470.    * kernel memory allocation routines
  471.    */
  472.   
  473. ! #define KERMEM_THRESHOLD QUANTUM-8
  474.   #define KMAGIC ((MEMREGION *)0x87654321L)
  475.   #define NKMAGIC 0x19870425L
  476.   
  477. --- 107,118 ----
  478.    * kernel memory allocation routines
  479.    */
  480.   
  481. ! #define KERMEM_THRESHOLD (QUANTUM-8)
  482. ! #if 0
  483. ! #define KERMEM_SIZE QUANTUM
  484. ! #else
  485. ! #define KERMEM_SIZE ((KERMEM_THRESHOLD+8)*2)
  486. ! #endif
  487.   #define KMAGIC ((MEMREGION *)0x87654321L)
  488.   #define NKMAGIC 0x19870425L
  489.   
  490. ***************
  491. *** 142,154 ****
  492.           DEBUG(("kmalloc(%lx): nalloc is out of memory",size));
  493.   
  494.       /* If this is commented out, then we fall through to try_getregion */
  495. !         if (0 == (m = get_region(alt, QUANTUM, PROT_S))) {
  496. !             if (0 == (m = get_region(core, QUANTUM, PROT_S))) {
  497.               DEBUG(("No memory for another arena"));
  498.               goto try_getregion;
  499.               }
  500.           }
  501. !         nalloc_arena_add((void *)m->loc,QUANTUM);
  502.           goto tryagain;
  503.           }
  504.       }
  505. --- 147,162 ----
  506.           DEBUG(("kmalloc(%lx): nalloc is out of memory",size));
  507.   
  508.       /* If this is commented out, then we fall through to try_getregion */
  509. !         if (0 == (m = get_region(alt, KERMEM_SIZE, PROT_S))) {
  510. !             if (0 == (m = get_region(core, KERMEM_SIZE, PROT_S))) {
  511.               DEBUG(("No memory for another arena"));
  512.               goto try_getregion;
  513.               }
  514.           }
  515. !         lp = (long *)m->loc;
  516. !         *lp++ = (long)KMAGIC;
  517. !         *lp++ = (long)m;
  518. !         nalloc_arena_add((void *)lp,KERMEM_SIZE);
  519.           goto tryagain;
  520.           }
  521.       }
  522. *** 1.8    1993/08/10 20:46:44
  523. --- xbios.c    1993/08/12 21:38:22
  524. ***************
  525. *** 29,35 ****
  526.    * unexpectedly. So we play some dirty tricks here: the function
  527.    * call is treated like a signal handler, and we take advantage
  528.    * of the fact that no context switches will take place while
  529. !  * in supervisor mode. ASSUMPTION: the user will not choose to
  530.    * switch back to user mode, or if s/he does it will be as part
  531.    * of a longjmp().
  532.    *
  533. --- 29,35 ----
  534.    * unexpectedly. So we play some dirty tricks here: the function
  535.    * call is treated like a signal handler, and we take advantage
  536.    * of the fact that no context switches will take place while
  537. !  * in supervisor mode. ASSTMPTION: the user will not choose to
  538.    * switch back to user mode, or if s/he does it will be as part
  539.    * of a longjmp().
  540.    *
  541. ***************
  542. *** 266,272 ****
  543.   {
  544.       MEMREGION *r;
  545.   
  546. !     if (!no_mem_prot) {
  547.       /* check that this process has access to the memory */
  548.       /* (if not, the next line will cause a bus error) */
  549.           (void)(*((volatile char *)ptr));
  550. --- 266,272 ----
  551.   {
  552.       MEMREGION *r;
  553.   
  554. !     if (!no_mem_prot && ((long)ptr >= 0)) {
  555.       /* check that this process has access to the memory */
  556.       /* (if not, the next line will cause a bus error) */
  557.           (void)(*((volatile char *)ptr));
  558. ***************
  559. *** 281,288 ****
  560.           }
  561.       }
  562.   
  563. !     Dosound(ptr);
  564. !     return 0;
  565.   }
  566.   
  567.   void
  568. --- 281,287 ----
  569.           }
  570.       }
  571.   
  572. !     return call_dosound(ptr);
  573.   }
  574.   
  575.   void
  576. *** 1.8    1993/08/10 20:46:44
  577. --- sproto.h    1993/08/12 21:41:30
  578. ***************
  579. *** 33,38 ****
  580. --- 33,39 ----
  581.   /* syscall.s */
  582.   char * ARGS_ON_STACK lineA0 P_((void));
  583.   void ARGS_ON_STACK call_aes P_((short **));
  584. + long ARGS_ON_STACK call_dosound P_((const void *));
  585.   long ARGS_ON_STACK callout P_((long, ...));
  586.   long ARGS_ON_STACK callout1 P_((long, int));
  587.   long ARGS_ON_STACK callout2 P_((long, int, int));
  588. *** 1.8    1993/08/10 20:46:44
  589. --- version.h    1993/08/12 21:20:36
  590. ***************
  591. *** 1,5 ****
  592.   #define MAJ_VERSION    1
  593. ! #define MIN_VERSION    8
  594.   
  595.   #ifndef MULTITOS
  596.   #define BETA
  597. --- 1,5 ----
  598.   #define MAJ_VERSION    1
  599. ! #define MIN_VERSION    9
  600.   
  601.   #ifndef MULTITOS
  602.   #define BETA
  603.